#include <iostream>
#include <thread>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdexcept>
#include <string>
#include <iostream>
#include "json.h" // 需要去GitHub上下载 https://github.com/nlohmann/json/releases/latest/download/json.hpp
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>

#include "opencv2/opencv.hpp"
#include "face.h"
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <iostream>
#include <chrono>
#include <ctime>
#include "sqlite3.h"
#include <stdexcept>
#include <vector>

using namespace std;
using json = nlohmann::json;
using namespace cv;
using namespace aip;
#define PORT 50000

    // 加载人脸检测分类器
CascadeClassifier Classifier("/usr/share/opencv/haarcascades/haarcascade_frontalface_alt2.xml");

    // 百度云api
std::string app_id = "115637414";
std::string api_key = "LuqtWCeWeloiEORqM7cuvMfi";
std::string secret_key = "G1VvB3dQY4C0Spr85ReYN9gGs9lgVnYO";
aip::Face client(app_id, api_key, secret_key);

//处理图片
string recognize() {
    Mat GrayImage;  // 存储转换后的灰度图像
    vector<Rect> Allface; // 存储检测到的人脸区域
    Mat MatFace; // 存储单个检测到的人脸
    vector<uchar> JpgFace; // 存储编码后的人脸图像
    string Base64Face; // 存储人脸的 Base64 编码
    Json::Value result; // 存储人脸识别的结果

    std::string image_type = "BASE64"; // 图像类型
    Json::Value jsonMap; // 用于存储请求参数


    std::string imagePath = "1.jpg";//
    
    // 加载图像到 ColorImage
    Mat ColorImage = imread(imagePath, IMREAD_COLOR);
         
        // 将彩色图像转换为灰度图像
    cvtColor(ColorImage, GrayImage, CV_BGR2GRAY);
        
        // 直方图均衡化，增强对比度
    equalizeHist(GrayImage, GrayImage);
        
        // 检测人脸
    Classifier.detectMultiScale(GrayImage, Allface, 1.1, 3, 0 | CASCADE_SCALE_IMAGE, Size(30, 30));
    cout << "Faces detected: " << Allface.size() << endl; // 输出检测到的人脸数量
        
        // 如果检测到人脸
        if (Allface.size()) {
            // 在灰度图上画出检测到的人脸框
            rectangle(GrayImage, Allface[0], Scalar(255, 255, 255));
            
            // 提取检测到的人脸
            MatFace = GrayImage(Allface[0]);
            
            // 编码人脸为 JPEG 格式
            imencode(".jpg", MatFace, JpgFace);
            
            // 将图像编码为 Base64
            Base64Face = base64_encode((char*)JpgFace.data(), JpgFace.size());
            
            // 调用百度云API 进行人脸搜索
            result = client.face_search_v3(Base64Face, image_type, "zyf", jsonMap);
            
            // 如果有识别结果
            if (!result["result"].isNull()) {
                // 检查识别的相似度分数
                if (result["result"]["user_list"][0]["score"].asInt() > 0) {

                    
                    // 输出识别到的用户 ID
                    cout << result["result"]["user_list"][0]["user_id"] << endl;
                    
                    return result["result"]["user_list"].isNull() ? "No results" : result["result"]["user_list"][0]["user_id"].asString();
                }
            }
        }
    
    return "no find";
}


// 解析 Base64
std::string base64_decode_1(const std::string &in) {
    static const std::string base64_chars =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "abcdefghijklmnopqrstuvwxyz"
        "0123456789+/";

    size_t in_len = in.size();
    if (in_len % 4 != 0) throw std::runtime_error("Input length is not a multiple of 4");

    size_t padding = 0;
    if (in_len > 0 && in[in_len - 1] == '=') padding++;
    if (in_len > 1 && in[in_len - 2] == '=') padding++;

    size_t out_len = (in_len / 4) * 3 - padding;
    std::vector<unsigned char> buffer(out_len);

    for (size_t i = 0, j = 0; i < in_len;) {
        uint32_t a = i < in_len ? base64_chars.find(in[i++]) : 0;
        uint32_t b = i < in_len ? base64_chars.find(in[i++]) : 0;
        uint32_t c = i < in_len ? base64_chars.find(in[i++]) : 0;
        uint32_t d = i < in_len ? base64_chars.find(in[i++]) : 0;

        uint32_t triple = (a << 3 * 6) + (b << 2 * 6) + (c << 1 * 6) + d;

        if (j < out_len) buffer[j++] = (triple >> 2 * 8) & 0xFF;
        if (j < out_len) buffer[j++] = (triple >> 1 * 8) & 0xFF;
        if (j < out_len) buffer[j++] = (triple >> 0 * 8) & 0xFF;
    }

    return std::string(buffer.begin(), buffer.end());
}

//使用tcp发回数据
void sendData(const std::string& address, int port, const std::string& message) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        std::cerr << "Socket creation failed" << std::endl;
        return;
    }

    sockaddr_in server_addr{};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    inet_pton(AF_INET, address.c_str(), &server_addr.sin_addr);


    //连接
    if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "Connection failed" << std::endl;
        close(sock);
        return;
    }

    send(sock, message.c_str(), message.size(), 0);
    close(sock);
}


// UDP 服务器处理函数
void runUdpServer() {
    int udpSock;
    struct sockaddr_in serverAddr, clientAddr;
    char buffer[1024 * 20];
    socklen_t addrLen = sizeof(clientAddr);
    
    // 创建 UDP 套接字
    if ((udpSock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("UDP socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 设置地址和端口
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(PORT);

    // 绑定
    if (bind(udpSock, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("UDP bind failed");
        close(udpSock);
        exit(EXIT_FAILURE);
    }


    std::cout << "UDP server running on port " << PORT << std::endl;

    // 接收数据
    while (true) {
        memset(buffer,0,sizeof(buffer));
        ssize_t recvLen = recvfrom(udpSock, buffer, sizeof(buffer) , 0, (struct sockaddr*)&clientAddr, &addrLen);
        if (recvLen < 0) {
            perror("UDP receive failed");
            continue;
        }
        cout << recvLen << endl;
        std::string data(buffer); 

    try {
        // 解析 JSON 数据
        auto obj = json::parse(data);
        std::string file_name = obj["file_name"];
        std::string file_type = obj["status"];
        std::string file_data = obj["file_data"];
        int file_size = obj["file_size"];

            // 解析 Base64 字符串
        std::string rawData = base64_decode_1(file_data);

        
        if (file_type == "new") {
        std::ofstream file(file_name, std::ios::binary | std::ios::trunc);//不存在就创建，存在就清空
            if (file.is_open()) {
                file.write(rawData.c_str(), rawData.size());

                // 不需要 seekg 和 tellg，使用 seekp 和 tellp
                file.seekp(0, std::ios::end); // 移动到文件末尾
                std::streamsize size = file.tellp(); // 获取文件的大小

                //文件已经传完了
                if (file_size == size) {
                    string ret = recognize();
                    char ipStr[INET_ADDRSTRLEN];//INET_ADDRSTRLEN，IPv4 地址的最大字符串长度
                    inet_ntop(AF_INET, &clientAddr.sin_addr, ipStr, sizeof(ipStr));

                    clientAddr.sin_port = htons(45000);
                    sendData(ipStr , 45000, ret); // 发送数据
                    cout << ipStr << endl;
                }

                file.close();
                std::cout << "新文件已创建: " << file_name << std::endl;
            } 
         } else if (file_type == "app") {
            std::ofstream file(file_name, std::ios::binary | std::ios::app);//不存在就创建，存在就清空
            if (file.is_open()) {
                file.write(rawData.c_str(), rawData.size());

                // 使用 seekp 和 tellp
                file.seekp(0, std::ios::end); // 移动到文件末尾
                std::streamsize size = file.tellp(); // 获取文件的大小
                //文件传完了
                if (file_size == size) {
                    string ret = recognize();

                    char ipStr[INET_ADDRSTRLEN];
                    inet_ntop(AF_INET, &clientAddr.sin_addr, ipStr, sizeof(ipStr));

                    clientAddr.sin_port = htons(45000);
                    sendData(ipStr , 45000, ret); // 发送数据
                    cout << ipStr << endl;
                }

                file.close();
            }  else {
                std::cerr << "无法打开文件: " << file_name << std::endl;
            }
        }
    } catch (const std::exception &e) {
        std::cerr << "解析 JSON 时出错: " << endl ;
     //   cout << data << endl;
        }
    }

    // 关闭套接字
    close(udpSock);
}

int main()
{

    // 创建 UDP 服务器线程
    std::thread udpThread(runUdpServer);

    udpThread.join();

    return 0;
}